home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 February: Tool Chest / Dev.CD Feb 95 / Dev.CD Feb 95.toast / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / interfaces / PInterface Translator / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1993-09-16  |  31.3 KB  |  1,003 lines  |  [TEXT/MPS ]
  1. {
  2. Created: Sunday, January 6, 1991 at 10:59 PM
  3.     Quickdraw.p
  4.     Pascal Interface to the Macintosh Libraries
  5.  
  6.         Copyright Apple Computer, Inc.    1985-1990
  7.         All rights reserved
  8. }
  9.  
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.     UNIT Quickdraw;
  17.     INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED UsingQuickdraw}
  21. {$SETC UsingQuickdraw := 1}
  22.  
  23. {$I+}
  24. {$SETC QuickdrawIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26. {$IFC UNDEFINED UsingTypes}
  27. {$I $$Shell(PInterfaces)Types.p}
  28. {$ENDC}
  29. {$SETC UsingIncludes := QuickdrawIncludes}
  30.  
  31. CONST
  32. invalColReq = -1;                           {invalid color table request}
  33.  
  34. { transfer modes }
  35. srcCopy = 0;                                {the 16 transfer modes}
  36. srcOr = 1;
  37. srcXor = 2;
  38. srcBic = 3;
  39. notSrcCopy = 4;
  40. notSrcOr = 5;
  41. notSrcXor = 6;
  42. notSrcBic = 7;
  43. patCopy = 8;
  44. patOr = 9;
  45. patXor = 10;
  46. patBic = 11;
  47. notPatCopy = 12;
  48. notPatOr = 13;
  49. notPatXor = 14;
  50. notPatBic = 15;
  51.  
  52. { Special Text Transfer Mode    }
  53. grayishTextOr = 49;
  54.  
  55. { Arithmetic transfer modes }
  56. blend = 32;
  57. addPin = 33;
  58. addOver = 34;
  59. subPin = 35;
  60. addMax = 37;
  61. adMax = 37;
  62. subOver = 38;
  63. adMin = 39;
  64. ditherCopy = 64;
  65.  
  66. { Transparent mode constant }
  67. transparent = 36;
  68.  
  69. { QuickDraw color separation constants }
  70. normalBit = 0;                              {normal screen mapping}
  71. inverseBit = 1;                             {inverse screen mapping}
  72. redBit = 4;                                 {RGB additive mapping}
  73. greenBit = 3;
  74. blueBit = 2;
  75. cyanBit = 8;                                {CMYBk subtractive mapping}
  76. magentaBit = 7;
  77. yellowBit = 6;
  78. blackBit = 5;
  79. blackColor = 33;                            {colors expressed in these mappings}
  80. whiteColor = 30;
  81. redColor = 205;
  82. greenColor = 341;
  83. blueColor = 409;
  84. cyanColor = 273;
  85. magentaColor = 137;
  86. yellowColor = 69;
  87.  
  88. picLParen = 0;                              {standard picture comments}
  89. picRParen = 1;
  90.  
  91.  
  92. clutType = 0;                               {0 if lookup table}
  93. fixedType = 1;                              {1 if fixed table}
  94. directType = 2;                             {2 if direct values}
  95.  
  96. gdDevType = 0;                              {0 = monochrome 1 = color}
  97. burstDevice = 7;
  98. ext32Device = 8;
  99. ramInit = 10;                               {1 if initialized from 'scrn' resource}
  100. mainScreen = 11;                            { 1 if main screen }
  101. allInit = 12;                               { 1 if all devices initialized }
  102. screenDevice = 13;                          {1 if screen device [not used]}
  103. noDriver = 14;                              { 1 if no driver for this GDevice }
  104. screenActive = 15;                          {1 if in use}
  105.  
  106. hiliteBit = 7;                              {flag bit in HiliteMode (lowMem flag)}
  107. pHiliteBit = 0;                             {flag bit in HiliteMode used with BitClr procedure}
  108.  
  109. defQDColors = 127;                          {resource ID of clut for default QDColors}
  110.  
  111. { pixel type }
  112. RGBDirect = 16;                             { 16 & 32 bits/pixel pixelType value }
  113.  
  114. { pmVersion values }
  115. baseAddr32 = 4;                             {pixmap base address is 32-bit address}
  116.  
  117. rgnOverflowErr = -147;                      { Region accumulation failed. Resulting region may be currupt }
  118. insufficientStackErr = -149;                { QuickDraw could not complete the operation }
  119.  
  120. TYPE
  121. GrafVerb = (frame,paint,erase,invert,fill);
  122.  
  123. PixelType = (chunky,chunkyPlanar,planar);
  124.  
  125.  
  126.  
  127. PatPtr = ^Pattern;
  128. PatHandle = ^PatPtr;
  129.  
  130. Pattern = PACKED ARRAY [0..7] OF 0..255;
  131.  
  132.  
  133.  
  134. QDByte = SignedByte;
  135.  
  136. QDPtr = Ptr;                                { blind pointer }
  137.  
  138. QDHandle = Handle;                          { blind handle }
  139.  
  140.  
  141.  
  142. QDErr = INTEGER;
  143.  
  144. Bits16 = ARRAY [0..15] OF INTEGER;
  145.  
  146.  
  147. StyleItem = (bold,italic,underline,outline,shadow,condense,extend);
  148.  
  149.  
  150. Style = SET OF StyleItem;
  151.  
  152.  
  153. DeviceLoopFlags = SET OF (singleDevices,dontMatchSeeds,allDevices,DeviceLoopFlags3,
  154.     DeviceLoopFlags4,DeviceLoopFlags5,DeviceLoopFlags6,DeviceLoopFlags7,DeviceLoopFlags8,
  155.     DeviceLoopFlags9,DeviceLoopFlags10,DeviceLoopFlags11,DeviceLoopFlags12,
  156.     DeviceLoopFlags13,DeviceLoopFlags14,DeviceLoopFlags15,DeviceLoopFlags16,
  157.     DeviceLoopFlags17,DeviceLoopFlags18,DeviceLoopFlags19,DeviceLoopFlags20,
  158.     DeviceLoopFlags21,DeviceLoopFlags22,DeviceLoopFlags23,DeviceLoopFlags24,
  159.     DeviceLoopFlags25,DeviceLoopFlags26,DeviceLoopFlags27,DeviceLoopFlags28,
  160.     DeviceLoopFlags29,DeviceLoopFlags30,DeviceLoopFlags31);
  161.  
  162.  
  163. FontInfo = RECORD
  164.     ascent: INTEGER;
  165.     descent: INTEGER;
  166.     widMax: INTEGER;
  167.     leading: INTEGER;
  168.     END;
  169.  
  170. BitMapPtr = ^BitMap;
  171. BitMapHandle = ^BitMapPtr;
  172. BitMap = RECORD
  173.     baseAddr: Ptr;
  174.     rowBytes: INTEGER;
  175.     bounds: Rect;
  176.     END;
  177.  
  178. CursPtr = ^Cursor;
  179. CursHandle = ^CursPtr;
  180. Cursor = RECORD
  181.     data: Bits16;
  182.     mask: Bits16;
  183.     hotSpot: Point;
  184.     END;
  185.  
  186. PenState = RECORD
  187.     pnLoc: Point;
  188.     pnSize: Point;
  189.     pnMode: INTEGER;
  190.     pnPat: Pattern;
  191.     END;
  192.  
  193. RgnPtr = ^Region;
  194. RgnHandle = ^RgnPtr;
  195. Region = RECORD
  196.     rgnSize: INTEGER;                       {size in bytes}
  197.     rgnBBox: Rect;                          {enclosing rectangle}
  198.     END;
  199.  
  200. PicPtr = ^Picture;
  201. PicHandle = ^PicPtr;
  202. Picture = RECORD
  203.     picSize: INTEGER;
  204.     picFrame: Rect;
  205.     END;
  206.  
  207. PolyPtr = ^Polygon;
  208. PolyHandle = ^PolyPtr;
  209. Polygon = RECORD
  210.     polySize: INTEGER;
  211.     polyBBox: Rect;
  212.     polyPoints: ARRAY [0..0] OF Point;
  213.     END;
  214.  
  215. QDProcsPtr = ^QDProcs;
  216. QDProcs = RECORD
  217.     textProc: Ptr;
  218.     lineProc: Ptr;
  219.     rectProc: Ptr;
  220.     rRectProc: Ptr;
  221.     ovalProc: Ptr;
  222.     arcProc: Ptr;
  223.     polyProc: Ptr;
  224.     rgnProc: Ptr;
  225.     bitsProc: Ptr;
  226.     commentProc: Ptr;
  227.     txMeasProc: Ptr;
  228.     getPicProc: Ptr;
  229.     putPicProc: Ptr;
  230.     END;
  231.  
  232. GrafPtr = ^GrafPort;
  233. GrafPort = RECORD
  234.     device: INTEGER;
  235.     portBits: BitMap;
  236.     portRect: Rect;
  237.     visRgn: RgnHandle;
  238.     clipRgn: RgnHandle;
  239.     bkPat: Pattern;
  240.     fillPat: Pattern;
  241.     pnLoc: Point;
  242.     pnSize: Point;
  243.     pnMode: INTEGER;
  244.     pnPat: Pattern;
  245.     pnVis: INTEGER;
  246.     txFont: INTEGER;
  247.     txFace: Style;                          {txFace is unpacked byte but push as short}
  248.     txMode: INTEGER;
  249.     txSize: INTEGER;
  250.     spExtra: Fixed;
  251.     fgColor: LONGINT;
  252.     bkColor: LONGINT;
  253.     colrBit: INTEGER;
  254.     patStretch: INTEGER;
  255.     picSave: Handle;
  256.     rgnSave: Handle;
  257.     polySave: Handle;
  258.     grafProcs: QDProcsPtr;
  259.     END;
  260.  
  261.  
  262. WindowPtr = GrafPtr;
  263.  
  264. {typedef pascal Boolean (*ColorSearchProcPtr)(RGBColor *rgb, long *position);
  265. typedef pascal Boolean (*ColorComplementProcPtr)(RGBColor *rgb);}
  266.  
  267. RGBColor = RECORD
  268.     red: INTEGER;                           {magnitude of red component}
  269.     green: INTEGER;                         {magnitude of green component}
  270.     blue: INTEGER;                          {magnitude of blue component}
  271.     END;
  272.  
  273. ColorSpecPtr = ^ColorSpec;
  274. ColorSpec = RECORD
  275.     value: INTEGER;                         {index or other value}
  276.     rgb: RGBColor;                          {true color}
  277.     END;
  278.  
  279.  
  280. CSpecArray = ARRAY [0..0] OF ColorSpec;
  281.  
  282. CTabPtr = ^ColorTable;
  283. CTabHandle = ^CTabPtr;
  284. ColorTable = RECORD
  285.     ctSeed: LONGINT;                        {unique identifier for table}
  286.     ctFlags: INTEGER;                       {high bit: 0 = PixMap; 1 = device}
  287.     ctSize: INTEGER;                        {number of entries in CTTable}
  288.     ctTable: CSpecArray;                    {array [0..0] of ColorSpec}
  289.     END;
  290.  
  291. MatchRec = RECORD
  292.     red: INTEGER;
  293.     green: INTEGER;
  294.     blue: INTEGER;
  295.     matchData: LONGINT;
  296.     END;
  297.  
  298. PixMapPtr = ^PixMap;
  299. PixMapHandle = ^PixMapPtr;
  300. PixMap = RECORD
  301.     baseAddr: Ptr;                          {pointer to pixels}
  302.     rowBytes: INTEGER;                      {offset to next line}
  303.     bounds: Rect;                           {encloses bitmap}
  304.     pmVersion: INTEGER;                     {pixMap version number}
  305.     packType: INTEGER;                      {defines packing format}
  306.     packSize: LONGINT;                      {length of pixel data}
  307.     hRes: Fixed;                            {horiz. resolution (ppi)}
  308.     vRes: Fixed;                            {vert. resolution (ppi)}
  309.     pixelType: INTEGER;                     {defines pixel type}
  310.     pixelSize: INTEGER;                     {# bits in pixel}
  311.     cmpCount: INTEGER;                      {# components in pixel}
  312.     cmpSize: INTEGER;                       {# bits per component}
  313.     planeBytes: LONGINT;                    {offset to next plane}
  314.     pmTable: CTabHandle;                    {color map for this pixMap}
  315.     pmReserved: LONGINT;                    {for future use. MUST BE 0}
  316.     END;
  317.  
  318. PixPatPtr = ^PixPat;
  319. PixPatHandle = ^PixPatPtr;
  320. PixPat = RECORD
  321.     patType: INTEGER;                       {type of pattern}
  322.     patMap: PixMapHandle;                   {the pattern's pixMap}
  323.     patData: Handle;                        {pixmap's data}
  324.     patXData: Handle;                       {expanded Pattern data}
  325.     patXValid: INTEGER;                     {flags whether expanded Pattern valid}
  326.     patXMap: Handle;                        {Handle to expanded Pattern data}
  327.     pat1Data: Pattern;                      {old-Style pattern/RGB color}
  328.     END;
  329.  
  330. CCrsrPtr = ^CCrsr;
  331. CCrsrHandle = ^CCrsrPtr;
  332. CCrsr = RECORD
  333.     crsrType: INTEGER;                      {type of cursor}
  334.     crsrMap: PixMapHandle;                  {the cursor's pixmap}
  335.     crsrData: Handle;                       {cursor's data}
  336.     crsrXData: Handle;                      {expanded cursor data}
  337.     crsrXValid: INTEGER;                    {depth of expanded data (0 if none)}
  338.     crsrXHandle: Handle;                    {future use}
  339.     crsr1Data: Bits16;                      {one-bit cursor}
  340.     crsrMask: Bits16;                       {cursor's mask}
  341.     crsrHotSpot: Point;                     {cursor's hotspot}
  342.     crsrXTable: LONGINT;                    {private}
  343.     crsrID: LONGINT;                        {private}
  344.     END;
  345.  
  346. CIconPtr = ^CIcon;
  347. CIconHandle = ^CIconPtr;
  348. CIcon = RECORD
  349.     iconPMap: PixMap;                       {the icon's pixMap}
  350.     iconMask: BitMap;                       {the icon's mask}
  351.     iconBMap: BitMap;                       {the icon's bitMap}
  352.     iconData: Handle;                       {the icon's data}
  353.     iconMaskData: ARRAY [0..0] OF INTEGER;  {icon's mask and BitMap data}
  354.     END;
  355.  
  356. GammaTblPtr = ^GammaTbl;
  357. GammaTblHandle = ^GammaTblPtr;
  358. GammaTbl = RECORD
  359.     gVersion: INTEGER;                      {gamma version number}
  360.     gType: INTEGER;                         {gamma data type}
  361.     gFormulaSize: INTEGER;                  {Formula data size}
  362.     gChanCnt: INTEGER;                      {number of channels of data}
  363.     gDataCnt: INTEGER;                      {number of values/channel}
  364.     gDataWidth: INTEGER;                    {bits/corrected value (data packed to next larger byte size)}
  365.     gFormulaData: ARRAY [0..0] OF INTEGER;  {data for formulas followed by gamma values}
  366.     END;
  367.  
  368. ITabPtr = ^ITab;
  369. ITabHandle = ^ITabPtr;
  370. ITab = RECORD
  371.     iTabSeed: LONGINT;                      {copy of CTSeed from source CTable}
  372.     iTabRes: INTEGER;                       {bits/channel resolution of iTable}
  373.     iTTable: ARRAY [0..0] OF SignedByte;    {byte colortable index values}
  374.     END;
  375.  
  376. SProcPtr = ^SProcRec;
  377. SProcHndl = ^SProcPtr;
  378. SProcRec = RECORD
  379.     nxtSrch: Handle;                        {Handle to next SProcRec}
  380.     srchProc: ProcPtr;                      {pointer to search procedure}
  381.     END;
  382.  
  383. CProcPtr = ^CProcRec;
  384. CProcHndl = ^CProcPtr;
  385. CProcRec = RECORD
  386.     nxtComp: CProcHndl;                     {CProcHndl Handle to next CProcRec}
  387.     compProc: ProcPtr;                      {pointer to complement procedure}
  388.     END;
  389.  
  390. GDPtr = ^GDevice;
  391. GDHandle = ^GDPtr;
  392. GDevice = RECORD
  393.     gdRefNum: INTEGER;                      {driver's unit number}
  394.     gdID: INTEGER;                          {client ID for search procs}
  395.     gdType: INTEGER;                        {fixed/CLUT/direct}
  396.     gdITable: ITabHandle;                   {Handle to inverse lookup table}
  397.     gdResPref: INTEGER;                     {preferred resolution of GDITable}
  398.     gdSearchProc: SProcHndl;                {search proc list head}
  399.     gdCompProc: CProcHndl;                  {complement proc list}
  400.     gdFlags: INTEGER;                       {grafDevice flags word}
  401.     gdPMap: PixMapHandle;                   {describing pixMap}
  402.     gdRefCon: LONGINT;                      {reference value}
  403.     gdNextGD: GDHandle;                     {GDHandle Handle of next gDevice}
  404.     gdRect: Rect;                           { device's bounds in global coordinates}
  405.     gdMode: LONGINT;                        {device's current mode}
  406.     gdCCBytes: INTEGER;                     {depth of expanded cursor data}
  407.     gdCCDepth: INTEGER;                     {depth of expanded cursor data}
  408.     gdCCXData: Handle;                      {Handle to cursor's expanded data}
  409.     gdCCXMask: Handle;                      {Handle to cursor's expanded mask}
  410.     gdReserved: LONGINT;                    {future use. MUST BE 0}
  411.     END;
  412.  
  413. GVarPtr = ^GrafVars;
  414. GVarHandle = ^GVarPtr;
  415. GrafVars = RECORD
  416.     rgbOpColor: RGBColor;                   {color for addPin  subPin and average}
  417.     rgbHiliteColor: RGBColor;               {color for hiliting}
  418.     pmFgColor: Handle;                      {palette Handle for foreground color}
  419.     pmFgIndex: INTEGER;                     {index value for foreground}
  420.     pmBkColor: Handle;                      {palette Handle for background color}
  421.     pmBkIndex: INTEGER;                     {index value for background}
  422.     pmFlags: INTEGER;                       {flags for Palette Manager}
  423.     END;
  424.  
  425. CQDProcsPtr = ^CQDProcs;
  426. CQDProcs = RECORD
  427.     textProc: Ptr;
  428.     lineProc: Ptr;
  429.     rectProc: Ptr;
  430.     rRectProc: Ptr;
  431.     ovalProc: Ptr;
  432.     arcProc: Ptr;
  433.     polyProc: Ptr;
  434.     rgnProc: Ptr;
  435.     bitsProc: Ptr;
  436.     commentProc: Ptr;
  437.     txMeasProc: Ptr;
  438.     getPicProc: Ptr;
  439.     putPicProc: Ptr;
  440.     opcodeProc: Ptr;                        {fields added to QDProcs}
  441.     newProc1: Ptr;
  442.     newProc2: Ptr;
  443.     newProc3: Ptr;
  444.     newProc4: Ptr;
  445.     newProc5: Ptr;
  446.     newProc6: Ptr;
  447.     END;
  448.  
  449. CGrafPtr = ^CGrafPort;
  450. CGrafPort = RECORD
  451.     device: INTEGER;
  452.     portPixMap: PixMapHandle;               {port's pixel map}
  453.     portVersion: INTEGER;                   {high 2 bits always set}
  454.     grafVars: Handle;                       {Handle to more fields}
  455.     chExtra: INTEGER;                       {character extra}
  456.     pnLocHFrac: INTEGER;                    {pen fraction}
  457.     portRect: Rect;
  458.     visRgn: RgnHandle;
  459.     clipRgn: RgnHandle;
  460.     bkPixPat: PixPatHandle;                 {background pattern}
  461.     rgbFgColor: RGBColor;                   {RGB components of fg}
  462.     rgbBkColor: RGBColor;                   {RGB components of bk}
  463.     pnLoc: Point;
  464.     pnSize: Point;
  465.     pnMode: INTEGER;
  466.     pnPixPat: PixPatHandle;                 {pen's pattern}
  467.     fillPixPat: PixPatHandle;               {fill pattern}
  468.     pnVis: INTEGER;
  469.     txFont: INTEGER;
  470.     txFace: Style;                          {txFace is unpacked byte  push as short}
  471.     txMode: INTEGER;
  472.     txSize: INTEGER;
  473.     spExtra: Fixed;
  474.     fgColor: LONGINT;
  475.     bkColor: LONGINT;
  476.     colrBit: INTEGER;
  477.     patStretch: INTEGER;
  478.     picSave: Handle;
  479.     rgnSave: Handle;
  480.     polySave: Handle;
  481.     grafProcs: CQDProcsPtr;
  482.     END;
  483.  
  484.  
  485. CWindowPtr = CGrafPtr;
  486.  
  487. ReqListRec = RECORD
  488.     reqLSize: INTEGER;                      {request list size}
  489.     reqLData: ARRAY [0..0] OF INTEGER;      {request list data}
  490.     END;
  491.  
  492. OpenCPicParams = RECORD
  493.     srcRect: Rect;
  494.     hRes: Fixed;
  495.     vRes: Fixed;
  496.     version: INTEGER;
  497.     reserved1: INTEGER;
  498.     reserved2: LONGINT;
  499.     END;
  500.  
  501.  
  502. DeviceLoopDrawingProcPtr = ProcPtr;
  503.  
  504.  
  505. VAR
  506. {$PUSH}
  507. {$J+}
  508.     thePort: GrafPtr;
  509.     white: Pattern;
  510.     black: Pattern;
  511.     gray: Pattern;
  512.     ltGray: Pattern;
  513.     dkGray: Pattern;
  514.     arrow: Cursor;
  515.     screenBits: BitMap;
  516.     randSeed: LONGINT;
  517. {$POP}
  518.  
  519.  
  520. PROCEDURE InitGraf(globalPtr: Ptr);
  521.     INLINE $A86E;
  522. PROCEDURE OpenPort(port: GrafPtr);
  523.     INLINE $A86F;
  524. PROCEDURE InitPort(port: GrafPtr);
  525.     INLINE $A86D;
  526. PROCEDURE ClosePort(port: GrafPtr);
  527.     INLINE $A87D;
  528. PROCEDURE SetPort(port: GrafPtr);
  529.     INLINE $A873;
  530. PROCEDURE GetPort(VAR port: GrafPtr);
  531.     INLINE $A874;
  532. PROCEDURE GrafDevice(device: INTEGER);
  533.     INLINE $A872;
  534. PROCEDURE SetPortBits(bm: BitMap);
  535.     INLINE $A875;
  536. PROCEDURE PortSize(width: INTEGER;height: INTEGER);
  537.     INLINE $A876;
  538. PROCEDURE MovePortTo(leftGlobal: INTEGER;topGlobal: INTEGER);
  539.     INLINE $A877;
  540. PROCEDURE SetOrigin(h: INTEGER;v: INTEGER);
  541.     INLINE $A878;
  542. PROCEDURE SetClip(rgn: RgnHandle);
  543.     INLINE $A879;
  544. PROCEDURE GetClip(rgn: RgnHandle);
  545.     INLINE $A87A;
  546. PROCEDURE ClipRect(r: Rect);
  547.     INLINE $A87B;
  548. PROCEDURE BackPat(pat: Pattern);
  549.     INLINE $A87C;
  550. PROCEDURE InitCursor;
  551.     INLINE $A850;
  552. PROCEDURE SetCursor(crsr: Cursor);
  553.     INLINE $A851;
  554. PROCEDURE HideCursor;
  555.     INLINE $A852;
  556. PROCEDURE ShowCursor;
  557.     INLINE $A853;
  558. PROCEDURE ObscureCursor;
  559.     INLINE $A856;
  560. PROCEDURE HidePen;
  561.     INLINE $A896;
  562. PROCEDURE ShowPen;
  563.     INLINE $A897;
  564. PROCEDURE GetPen(VAR pt: Point);
  565.     INLINE $A89A;
  566. PROCEDURE GetPenState(VAR pnState: PenState);
  567.     INLINE $A898;
  568. PROCEDURE SetPenState(pnState: PenState);
  569.     INLINE $A899;
  570. PROCEDURE PenSize(width: INTEGER;height: INTEGER);
  571.     INLINE $A89B;
  572. PROCEDURE PenMode(mode: INTEGER);
  573.     INLINE $A89C;
  574. PROCEDURE PenPat(pat: Pattern);
  575.     INLINE $A89D;
  576. PROCEDURE PenNormal;
  577.     INLINE $A89E;
  578. PROCEDURE MoveTo(h: INTEGER;v: INTEGER);
  579.     INLINE $A893;
  580. PROCEDURE Move(dh: INTEGER;dv: INTEGER);
  581.     INLINE $A894;
  582. PROCEDURE LineTo(h: INTEGER;v: INTEGER);
  583.     INLINE $A891;
  584. PROCEDURE Line(dh: INTEGER;dv: INTEGER);
  585.     INLINE $A892;
  586. PROCEDURE TextFont(font: INTEGER);
  587.     INLINE $A887;
  588. PROCEDURE TextFace(face: Style);
  589.     INLINE $A888;
  590. PROCEDURE TextMode(mode: INTEGER);
  591.     INLINE $A889;
  592. PROCEDURE TextSize(size: INTEGER);
  593.     INLINE $A88A;
  594. PROCEDURE SpaceExtra(extra: Fixed);
  595.     INLINE $A88E;
  596. PROCEDURE DrawChar(ch: CHAR);
  597.     INLINE $A883;
  598. PROCEDURE DrawString(s: Str255);
  599.     INLINE $A884;
  600. PROCEDURE DrawText(textBuf: Ptr;firstByte: INTEGER;byteCount: INTEGER);
  601.     INLINE $A885;
  602. FUNCTION CharWidth(ch: CHAR): INTEGER;
  603.     INLINE $A88D;
  604. FUNCTION StringWidth(s: Str255): INTEGER;
  605.     INLINE $A88C;
  606. FUNCTION TextWidth(textBuf: Ptr;firstByte: INTEGER;byteCount: INTEGER): INTEGER;
  607.     INLINE $A886;
  608. PROCEDURE MeasureText(count: INTEGER;textAddr: Ptr;charLocs: Ptr);
  609.     INLINE $A837;
  610. PROCEDURE GetFontInfo(VAR info: FontInfo);
  611.     INLINE $A88B;
  612. PROCEDURE ForeColor(color: LONGINT);
  613.     INLINE $A862;
  614. PROCEDURE BackColor(color: LONGINT);
  615.     INLINE $A863;
  616. PROCEDURE ColorBit(whichBit: INTEGER);
  617.     INLINE $A864;
  618. PROCEDURE SetRect(VAR r: Rect;left: INTEGER;top: INTEGER;right: INTEGER;
  619.     bottom: INTEGER);
  620.     INLINE $A8A7;
  621. PROCEDURE OffsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  622.     INLINE $A8A8;
  623. PROCEDURE InsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  624.     INLINE $A8A9;
  625. FUNCTION SectRect(src1: Rect;src2: Rect;VAR dstRect: Rect): BOOLEAN;
  626.     INLINE $A8AA;
  627. PROCEDURE UnionRect(src1: Rect;src2: Rect;VAR dstRect: Rect);
  628.     INLINE $A8AB;
  629. FUNCTION EqualRect(rect1: Rect;rect2: Rect): BOOLEAN;
  630.     INLINE $A8A6;
  631. FUNCTION EmptyRect(r: Rect): BOOLEAN;
  632.     INLINE $A8AE;
  633. PROCEDURE FrameRect(r: Rect);
  634.     INLINE $A8A1;
  635. PROCEDURE PaintRect(r: Rect);
  636.     INLINE $A8A2;
  637. PROCEDURE EraseRect(r: Rect);
  638.     INLINE $A8A3;
  639. PROCEDURE InvertRect(r: Rect);
  640.     INLINE $A8A4;
  641. PROCEDURE FillRect(r: Rect;pat: Pattern);
  642.     INLINE $A8A5;
  643. PROCEDURE FrameOval(r: Rect);
  644.     INLINE $A8B7;
  645. PROCEDURE PaintOval(r: Rect);
  646.     INLINE $A8B8;
  647. PROCEDURE EraseOval(r: Rect);
  648.     INLINE $A8B9;
  649. PROCEDURE InvertOval(r: Rect);
  650.     INLINE $A8BA;
  651. PROCEDURE FillOval(r: Rect;pat: Pattern);
  652.     INLINE $A8BB;
  653. PROCEDURE FrameRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  654.     INLINE $A8B0;
  655. PROCEDURE PaintRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  656.     INLINE $A8B1;
  657. PROCEDURE EraseRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  658.     INLINE $A8B2;
  659. PROCEDURE InvertRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  660.     INLINE $A8B3;
  661. PROCEDURE FillRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  662.     pat: Pattern);
  663.     INLINE $A8B4;
  664. PROCEDURE FrameArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  665.     INLINE $A8BE;
  666. PROCEDURE PaintArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  667.     INLINE $A8BF;
  668. PROCEDURE EraseArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  669.     INLINE $A8C0;
  670. PROCEDURE InvertArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  671.     INLINE $A8C1;
  672. PROCEDURE FillArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pat: Pattern);
  673.     INLINE $A8C2;
  674. FUNCTION NewRgn: RgnHandle;
  675.     INLINE $A8D8;
  676. PROCEDURE OpenRgn;
  677.     INLINE $A8DA;
  678. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  679.     INLINE $A8DB;
  680. FUNCTION BitMapToRegionGlue(region: RgnHandle;bMap: BitMap): OSErr;
  681. FUNCTION BitMapToRegion(region: RgnHandle;bMap: BitMap): OSErr;
  682.     INLINE $A8D7;
  683. PROCEDURE DisposeRgn(rgn: RgnHandle);
  684.     INLINE $A8D9;
  685. PROCEDURE CopyRgn(srcRgn: RgnHandle;dstRgn: RgnHandle);
  686.     INLINE $A8DC;
  687. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  688.     INLINE $A8DD;
  689. PROCEDURE SetRectRgn(rgn: RgnHandle;left: INTEGER;top: INTEGER;right: INTEGER;
  690.     bottom: INTEGER);
  691.     INLINE $A8DE;
  692. PROCEDURE RectRgn(rgn: RgnHandle;r: Rect);
  693.     INLINE $A8DF;
  694. PROCEDURE OffsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  695.     INLINE $A8E0;
  696. PROCEDURE InsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  697.     INLINE $A8E1;
  698. PROCEDURE SectRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  699.     INLINE $A8E4;
  700. PROCEDURE UnionRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  701.     INLINE $A8E5;
  702. PROCEDURE DiffRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  703.     INLINE $A8E6;
  704. PROCEDURE XorRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  705.     INLINE $A8E7;
  706. FUNCTION RectInRgn(r: Rect;rgn: RgnHandle): BOOLEAN;
  707.     INLINE $A8E9;
  708. FUNCTION EqualRgn(rgnA: RgnHandle;rgnB: RgnHandle): BOOLEAN;
  709.     INLINE $A8E3;
  710. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  711.     INLINE $A8E2;
  712. PROCEDURE FrameRgn(rgn: RgnHandle);
  713.     INLINE $A8D2;
  714. PROCEDURE PaintRgn(rgn: RgnHandle);
  715.     INLINE $A8D3;
  716. PROCEDURE EraseRgn(rgn: RgnHandle);
  717.     INLINE $A8D4;
  718. PROCEDURE InvertRgn(rgn: RgnHandle);
  719.     INLINE $A8D5;
  720. PROCEDURE FillRgn(rgn: RgnHandle;pat: Pattern);
  721.     INLINE $A8D6;
  722. PROCEDURE ScrollRect(r: Rect;dh: INTEGER;dv: INTEGER;updateRgn: RgnHandle);
  723.     INLINE $A8EF;
  724. PROCEDURE CopyBits(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  725.     mode: INTEGER;maskRgn: RgnHandle);
  726.     INLINE $A8EC;
  727. PROCEDURE SeedFill(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  728.     height: INTEGER;words: INTEGER;seedH: INTEGER;seedV: INTEGER);
  729.     INLINE $A839;
  730. PROCEDURE CalcMask(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  731.     height: INTEGER;words: INTEGER);
  732.     INLINE $A838;
  733. PROCEDURE CopyMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;srcRect: Rect;
  734.     maskRect: Rect;dstRect: Rect);
  735.     INLINE $A817;
  736. FUNCTION OpenPicture(picFrame: Rect): PicHandle;
  737.     INLINE $A8F3;
  738. PROCEDURE PicComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  739.     INLINE $A8F2;
  740. PROCEDURE ClosePicture;
  741.     INLINE $A8F4;
  742. PROCEDURE DrawPicture(myPicture: PicHandle;dstRect: Rect);
  743.     INLINE $A8F6;
  744. PROCEDURE KillPicture(myPicture: PicHandle);
  745.     INLINE $A8F5;
  746. FUNCTION OpenPoly: PolyHandle;
  747.     INLINE $A8CB;
  748. PROCEDURE ClosePoly;
  749.     INLINE $A8CC;
  750. PROCEDURE KillPoly(poly: PolyHandle);
  751.     INLINE $A8CD;
  752. PROCEDURE OffsetPoly(poly: PolyHandle;dh: INTEGER;dv: INTEGER);
  753.     INLINE $A8CE;
  754. PROCEDURE FramePoly(poly: PolyHandle);
  755.     INLINE $A8C6;
  756. PROCEDURE PaintPoly(poly: PolyHandle);
  757.     INLINE $A8C7;
  758. PROCEDURE ErasePoly(poly: PolyHandle);
  759.     INLINE $A8C8;
  760. PROCEDURE InvertPoly(poly: PolyHandle);
  761.     INLINE $A8C9;
  762. PROCEDURE FillPoly(poly: PolyHandle;pat: Pattern);
  763.     INLINE $A8CA;
  764. PROCEDURE SetPt(VAR pt: Point;h: INTEGER;v: INTEGER);
  765.     INLINE $A880;
  766. PROCEDURE LocalToGlobal(VAR pt: Point);
  767.     INLINE $A870;
  768. PROCEDURE GlobalToLocal(VAR pt: Point);
  769.     INLINE $A871;
  770. FUNCTION Random: INTEGER;
  771.     INLINE $A861;
  772. PROCEDURE StuffHex(thingPtr: Ptr;s: Str255);
  773.     INLINE $A866;
  774. FUNCTION GetPixel(h: INTEGER;v: INTEGER): BOOLEAN;
  775.     INLINE $A865;
  776. PROCEDURE ScalePt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  777.     INLINE $A8F8;
  778. PROCEDURE MapPt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  779.     INLINE $A8F9;
  780. PROCEDURE MapRect(VAR r: Rect;srcRect: Rect;dstRect: Rect);
  781.     INLINE $A8FA;
  782. PROCEDURE MapRgn(rgn: RgnHandle;srcRect: Rect;dstRect: Rect);
  783.     INLINE $A8FB;
  784. PROCEDURE MapPoly(poly: PolyHandle;srcRect: Rect;dstRect: Rect);
  785.     INLINE $A8FC;
  786. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  787.     INLINE $A8EA;
  788. PROCEDURE StdRect(verb: GrafVerb;r: Rect);
  789.     INLINE $A8A0;
  790. PROCEDURE StdRRect(verb: GrafVerb;r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  791.     INLINE $A8AF;
  792. PROCEDURE StdOval(verb: GrafVerb;r: Rect);
  793.     INLINE $A8B6;
  794. PROCEDURE StdArc(verb: GrafVerb;r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  795.     INLINE $A8BD;
  796. PROCEDURE StdPoly(verb: GrafVerb;poly: PolyHandle);
  797.     INLINE $A8C5;
  798. PROCEDURE StdRgn(verb: GrafVerb;rgn: RgnHandle);
  799.     INLINE $A8D1;
  800. PROCEDURE StdBits(VAR srcBits: BitMap;VAR srcRect: Rect;dstRect: Rect;mode: INTEGER;
  801.     maskRgn: RgnHandle);
  802.     INLINE $A8EB;
  803. PROCEDURE StdComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  804.     INLINE $A8F1;
  805. FUNCTION StdTxMeas(byteCount: INTEGER;textAddr: Ptr;VAR numer: Point;VAR denom: Point;
  806.     VAR info: FontInfo): INTEGER;
  807.     INLINE $A8ED;
  808. PROCEDURE StdGetPic(dataPtr: Ptr;byteCount: INTEGER);
  809.     INLINE $A8EE;
  810. PROCEDURE StdPutPic(dataPtr: Ptr;byteCount: INTEGER);
  811.     INLINE $A8F0;
  812. PROCEDURE AddPt(src: Point;VAR dst: Point);
  813.     INLINE $A87E;
  814. FUNCTION EqualPt(pt1: Point;pt2: Point): BOOLEAN;
  815.     INLINE $A881;
  816. FUNCTION PtInRect(pt: Point;r: Rect): BOOLEAN;
  817.     INLINE $A8AD;
  818. PROCEDURE Pt2Rect(pt1: Point;pt2: Point;VAR dstRect: Rect);
  819.     INLINE $A8AC;
  820. PROCEDURE PtToAngle(r: Rect;pt: Point;VAR angle: INTEGER);
  821.     INLINE $A8C3;
  822. FUNCTION PtInRgn(pt: Point;rgn: RgnHandle): BOOLEAN;
  823.     INLINE $A8E8;
  824. PROCEDURE StdText(count: INTEGER;textAddr: Ptr;numer: Point;denom: Point);
  825.     INLINE $A882;
  826. PROCEDURE StdLine(newPt: Point);
  827.     INLINE $A890;
  828. PROCEDURE OpenCPort(port: CGrafPtr);
  829.     INLINE $AA00;
  830. PROCEDURE InitCPort(port: CGrafPtr);
  831.     INLINE $AA01;
  832. PROCEDURE CloseCPort(port: CGrafPtr);
  833.     INLINE $A87D;
  834. FUNCTION NewPixMap: PixMapHandle;
  835.     INLINE $AA03;
  836. PROCEDURE DisposPixMap(pm: PixMapHandle);
  837.     INLINE $AA04;
  838. PROCEDURE DisposePixMap(pm: PixMapHandle);
  839.     INLINE $AA04;
  840. PROCEDURE CopyPixMap(srcPM: PixMapHandle;dstPM: PixMapHandle);
  841.     INLINE $AA05;
  842. FUNCTION NewPixPat: PixPatHandle;
  843.     INLINE $AA07;
  844. PROCEDURE DisposPixPat(pp: PixPatHandle);
  845.     INLINE $AA08;
  846. PROCEDURE DisposePixPat(pp: PixPatHandle);
  847.     INLINE $AA08;
  848. PROCEDURE CopyPixPat(srcPP: PixPatHandle;dstPP: PixPatHandle);
  849.     INLINE $AA09;
  850. PROCEDURE PenPixPat(pp: PixPatHandle);
  851.     INLINE $AA0A;
  852. PROCEDURE BackPixPat(pp: PixPatHandle);
  853.     INLINE $AA0B;
  854. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  855.     INLINE $AA0C;
  856. PROCEDURE MakeRGBPat(pp: PixPatHandle;myColor: RGBColor);
  857.     INLINE $AA0D;
  858. PROCEDURE FillCRect(r: Rect;pp: PixPatHandle);
  859.     INLINE $AA0E;
  860. PROCEDURE FillCOval(r: Rect;pp: PixPatHandle);
  861.     INLINE $AA0F;
  862. PROCEDURE FillCRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  863.     pp: PixPatHandle);
  864.     INLINE $AA10;
  865. PROCEDURE FillCArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pp: PixPatHandle);
  866.     INLINE $AA11;
  867. PROCEDURE FillCRgn(rgn: RgnHandle;pp: PixPatHandle);
  868.     INLINE $AA12;
  869. PROCEDURE FillCPoly(poly: PolyHandle;pp: PixPatHandle);
  870.     INLINE $AA13;
  871. PROCEDURE RGBForeColor(color: RGBColor);
  872.     INLINE $AA14;
  873. PROCEDURE RGBBackColor(color: RGBColor);
  874.     INLINE $AA15;
  875. PROCEDURE SetCPixel(h: INTEGER;v: INTEGER;cPix: RGBColor);
  876.     INLINE $AA16;
  877. PROCEDURE SetPortPix(pm: PixMapHandle);
  878.     INLINE $AA06;
  879. PROCEDURE GetCPixel(h: INTEGER;v: INTEGER;VAR cPix: RGBColor);
  880.     INLINE $AA17;
  881. PROCEDURE GetForeColor(VAR color: RGBColor);
  882.     INLINE $AA19;
  883. PROCEDURE GetBackColor(VAR color: RGBColor);
  884.     INLINE $AA1A;
  885. PROCEDURE SeedCFill(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  886.     seedH: INTEGER;seedV: INTEGER;matchProc: ProcPtr;matchData: LONGINT);
  887.     INLINE $AA50;
  888. PROCEDURE CalcCMask(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  889.     seedRGB: RGBColor;matchProc: ProcPtr;matchData: LONGINT);
  890.     INLINE $AA4F;
  891. FUNCTION OpenCPicture(newHeader: OpenCPicParams): PicHandle;
  892.     INLINE $AA20;
  893. PROCEDURE OpColor(color: RGBColor);
  894.     INLINE $AA21;
  895. PROCEDURE HiliteColor(color: RGBColor);
  896.     INLINE $AA22;
  897. PROCEDURE DisposCTable(cTable: CTabHandle);
  898.     INLINE $AA24;
  899. PROCEDURE DisposeCTable(cTable: CTabHandle);
  900.     INLINE $AA24;
  901. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  902.     INLINE $AA18;
  903. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  904.     INLINE $AA1B;
  905. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  906.     INLINE $AA1C;
  907. PROCEDURE AllocCursor;
  908.     INLINE $AA1D;
  909. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  910.     INLINE $AA26;
  911. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  912.     INLINE $AA26;
  913. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  914.     INLINE $AA1E;
  915. PROCEDURE PlotCIcon(theRect: Rect;theIcon: CIconHandle);
  916.     INLINE $AA1F;
  917. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  918.     INLINE $AA25;
  919. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  920.     INLINE $AA25;
  921. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  922.     INLINE $AA4E;
  923. PROCEDURE CharExtra(extra: Fixed);
  924.     INLINE $AA23;
  925. FUNCTION GetMaxDevice(globalRect: Rect): GDHandle;
  926.     INLINE $AA27;
  927. FUNCTION GetCTSeed: LONGINT;
  928.     INLINE $AA28;
  929. FUNCTION GetDeviceList: GDHandle;
  930.     INLINE $AA29;
  931. FUNCTION GetMainDevice: GDHandle;
  932.     INLINE $AA2A;
  933. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  934.     INLINE $AA2B;
  935. FUNCTION TestDeviceAttribute(gdh: GDHandle;attribute: INTEGER): BOOLEAN;
  936.     INLINE $AA2C;
  937. PROCEDURE SetDeviceAttribute(gdh: GDHandle;attribute: INTEGER;value: BOOLEAN);
  938.     INLINE $AA2D;
  939. PROCEDURE InitGDevice(qdRefNum: INTEGER;mode: LONGINT;gdh: GDHandle);
  940.     INLINE $AA2E;
  941. FUNCTION NewGDevice(refNum: INTEGER;mode: LONGINT): GDHandle;
  942.     INLINE $AA2F;
  943. PROCEDURE DisposGDevice(gdh: GDHandle);
  944.     INLINE $AA30;
  945. PROCEDURE DisposeGDevice(gdh: GDHandle);
  946.     INLINE $AA30;
  947. PROCEDURE SetGDevice(gd: GDHandle);
  948.     INLINE $AA31;
  949. FUNCTION GetGDevice: GDHandle;
  950.     INLINE $AA32;
  951. FUNCTION Color2Index(myColor: RGBColor): LONGINT;
  952.     INLINE $AA33;
  953. PROCEDURE Index2Color(index: LONGINT;VAR aColor: RGBColor);
  954.     INLINE $AA34;
  955. PROCEDURE InvertColor(VAR myColor: RGBColor);
  956.     INLINE $AA35;
  957. FUNCTION RealColor(color: RGBColor): BOOLEAN;
  958.     INLINE $AA36;
  959. PROCEDURE GetSubTable(myColors: CTabHandle;iTabRes: INTEGER;targetTbl: CTabHandle);
  960.     INLINE $AA37;
  961. PROCEDURE MakeITable(cTabH: CTabHandle;iTabH: ITabHandle;res: INTEGER);
  962.     INLINE $AA39;
  963. PROCEDURE AddSearch(searchProc: ProcPtr);
  964.     INLINE $AA3A;
  965. PROCEDURE AddComp(compProc: ProcPtr);
  966.     INLINE $AA3B;
  967. PROCEDURE DelSearch(searchProc: ProcPtr);
  968.     INLINE $AA4C;
  969. PROCEDURE DelComp(compProc: ProcPtr);
  970.     INLINE $AA4D;
  971. PROCEDURE SubPt(src: Point;VAR dst: Point);
  972.     INLINE $A87F;
  973. PROCEDURE SetClientID(id: INTEGER);
  974.     INLINE $AA3C;
  975. PROCEDURE ProtectEntry(index: INTEGER;protect: BOOLEAN);
  976.     INLINE $AA3D;
  977. PROCEDURE ReserveEntry(index: INTEGER;reserve: BOOLEAN);
  978.     INLINE $AA3E;
  979. PROCEDURE SetEntries(start: INTEGER;count: INTEGER;aTable: CSpecArray);
  980.     INLINE $AA3F;
  981. PROCEDURE SaveEntries(srcTable: CTabHandle;resultTable: CTabHandle;VAR selection: ReqListRec);
  982.     INLINE $AA49;
  983. PROCEDURE RestoreEntries(srcTable: CTabHandle;dstTable: CTabHandle;VAR selection: ReqListRec);
  984.     INLINE $AA4A;
  985. FUNCTION QDError: INTEGER;
  986.     INLINE $AA40;
  987. PROCEDURE CopyDeepMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;
  988.     srcRect: Rect;maskRect: Rect;dstRect: Rect;mode: INTEGER;maskRgn: RgnHandle);
  989.     INLINE $AA51;
  990. PROCEDURE DeviceLoop(drawingRgn: RgnHandle;drawingProc: DeviceLoopDrawingProcPtr;
  991.     userData: LONGINT;flags: DeviceLoopFlags);
  992.     INLINE $ABCA;
  993. FUNCTION GetMaskTable: Ptr;
  994.     INLINE $A836,$2E88;
  995.  
  996.  
  997. {$ENDC}    { UsingQuickdraw }
  998.  
  999. {$IFC NOT UsingIncludes}
  1000.     END.
  1001. {$ENDC}
  1002.  
  1003.